[Rust] N-APIアドオンを作成してTypeScriptコードを変換する [Bun 1.2]

% curl -fsSL https://bun.sh/install | bash # for macOS, Linux, and WSL

# すでにインストールしている場合はupgrade
% bun upgrade

% bun add -g @napi-rs/cli
% bun add -g yarn

% cd my-bun-plugin
% napi new

? Package name: (The name filed in your package.json) napi-example
? Dir name: napi-example
? Choose targets you want to support x86_64-apple-darwin, x86_64-pc-windows-msvc, x86_64-unknown-linux-gnu
? Enable github actions? No
・・・
➤ YN0000: · Done in 2s 813ms

% cargo add bun-native-plugin

    Updating crates.io index
      Adding bun-native-plugin v0.1.2 to dependencies
             Features:
             + napi
    Updating crates.io index
     Locking 34 packages to latest compatible versions

use bun_native_plugin::{define_bun_plugin, OnBeforeParse, bun, Result, anyhow, BunLoader};
use napi_derive::napi;

/// Define the plugin and its name
define_bun_plugin!("replace-foo-with-bar");

/// Here we'll implement `onBeforeParse` with code that replaces all occurrences of
/// `foo` with `bar`.
///
/// We use the #[bun] macro to generate some of the boilerplate code.
///
/// The argument of the function (`handle: &mut OnBeforeParse`) tells
/// the macro that this function implements the `onBeforeParse` hook.
#[bun]
pub fn replace_foo_with_bar(handle: &mut OnBeforeParse) -> Result<()> {
  // Fetch the input source code.
  let input_source_code = handle.input_source_code()?;

  // Get the Loader for the file
  let loader = handle.output_loader();

  let output_source_code = input_source_code.replace("foo", "bar");

  handle.set_output_source_code(output_source_code, BunLoader::BUN_LOADER_JSX);

  Ok(())
}

% bun run build

$ napi build --platform --release

・・・・

warning: `napi-example` (lib) generated 3 warnings (run `cargo fix --lib -p napi-example` to apply 1 suggestion)
    Finished `release` profile [optimized] target(s) in 9.56s

// test.ts
console.log("foo is here");
const message = "foo foo foo";

% bun run test.ts 
foo is here

//build.js
const path = require("path");

const result = await Bun.build({
  entrypoints: ["./test.ts"],
  outdir: "./dist",
  plugins: [
    {
      name: "replace-foo-with-bar",
      setup(build) {
        // プラグインファイルへの絶対パス
        const napiModule = require(path.resolve("./napi-example.darwin-arm64.node"));

        build.onBeforeParse(
          {
            filter: /\.tsx?$/,  // .ts または .tsx ファイルに適用
            namespace: "file"
          },
          {
            napiModule,
            symbol: "replace_foo_with_bar"
          }
        );

        build.onStart(() => {
          console.log("Build started!");
        });
      }
    }
  ],
  // ソースマップを生成して確認しやすくする
  sourcemap: "external",
});

console.log("Build completed!");
console.log("Outputs:", result.outputs.map(o => o.path));

% bun run build.js
Build started!
Build completed!
Outputs: [ "/・・・/dist/test.js", "/・・・/dist/test.js.map" ]

% bun run dist/test.js

bar is here

let x:string = "foo";

BunLoader::BUN_LOADER_JSX
↓
BunLoader::BUN_LOADER_TSX

% cargo add swc_common swc_ecma_parser swc_ecma_ast

//lib.rs
use bun_native_plugin::{define_bun_plugin, bun, Result, BunLoader};
use napi_derive::napi;
use swc_ecma_parser::{lexer::Lexer, Parser, StringInput, Syntax};
use swc_common::{SourceMap, FileName};
use std::sync::Arc;

define_bun_plugin!("replace-foo-with-bar");

#[bun]
pub fn replace_foo_with_bar(handle: &mut OnBeforeParse) -> Result<()> {
    // 入力ソースコードを取得
    let input_source_code = handle.input_source_code()?;

    // パース処理の準備
    let source_map = SourceMap::default();
    let source_file = source_map.new_source_file(
        FileName::Anon.into(), 
        input_source_code.to_string(), 
    );

    // setting lexer&parser
    let lexer = Lexer::new(
        Syntax::Es(Default::default()),
        Default::default(),
        StringInput::from(&*source_file),
        None,
    );
    let mut parser = Parser::new_from(lexer);

    match parser.parse_module() {
        Ok(module) => {
            println!("=== Parsed Module Structure ===");
            println!("Module: {:#?}", module);

            // モジュール内の各要素を解析
            for item in module.body {
                match item {
                    swc_ecma_ast::ModuleItem::Stmt(stmt) => {
                        println!("Statement: {:#?}", stmt);
                    }
                    swc_ecma_ast::ModuleItem::ModuleDecl(decl) => {
                        println!("Module Declaration: {:#?}", decl);
                    }
                }
            }
        }
        Err(err) => {
            println!("Parse error: {:?}", err);
        }
    }

    let output_source_code = input_source_code.replace("foo", "bar");
    handle.set_output_source_code(output_source_code, BunLoader::BUN_LOADER_JSX);

    Ok(())
}

% bun run build.js
Build started!
=== Parsed Module Structure ===
Module: Module {
    span: 13..104,
    body: [
        Stmt(
            Decl(
                Var(
                    VarDecl {
                        span: 13..31,
                        ctxt: #0,
                        kind: "const",
                        declare: false,
                        decls: [
・・・
                callee: Expr(
                    Ident(
                        Ident {
                            span: 90..101,
                            ctxt: #0,
                            sym: "my_function",
                            optional: false,
                        },
                    ),
                ),
                args: [],
                type_args: None,
            },
        ),
    },
)
Build completed!